//! 环绕迭代器
//! 以某点为中心，输入中心点和半径后，返回对应范围
//! 如 [1,2,3,4,5] 输入中心点为 2 和 半径为 1，那么输出就是 [2,3,4]
//! 上述例子如果输入的半径大于原始数据的范围，如中心店为 1 和半径为 2，输出则为 [1,2,3,4]
//!
//!

#[derive(Clone, Debug)]
pub struct WrapIter<I> {
    iter: I,
    center: usize,
    radius: usize,
    size: i32,
}

impl<I> WrapIter<I> {
    pub fn new(iter: I, center: usize, radius: usize) -> Self <> {
        WrapIter {
            iter,
            center,
            radius,
            size: -1,
        }
    }
}

impl<I> Iterator for WrapIter<I>
    where I: Iterator {
    type Item = I::Item;

    fn next(&mut self) -> Option<Self::Item> {
        if self.size < 0 {
            // =====说明还没初始化=====
            if self.radius > self.center {
                self.size = (self.center + self.radius) as i32;
                self.iter.next()
            } else {
                self.size = (2 * self.radius + 1) as i32;
                let old_n = self.center - self.radius;
                self.iter.nth(old_n)
            }
        } else if self.size != 0 {
            self.size -= 1;
            self.iter.next()
        } else {
            None
        }
    }
}

pub trait WrapIterExt: Iterator {
    fn wrap_iter(self, center: usize, radius: usize) -> WrapIter<Self>
        where Self: Sized {
        WrapIter::new(self, center, radius)
    }
}

impl<T: ?Sized> WrapIterExt for T where T: Iterator {}


#[cfg(test)]
mod test {
    use crate::util::wrap_iter::WrapIterExt;

    #[test]
    fn test_01() {
        let res = [1, 2, 3, 4, 5].iter().wrap_iter(2, 2).map(|a|*a).collect::<Vec<i32>>();
        assert_eq!(&res, &[1, 2, 3, 4, 5]);
    }

    #[test]
    fn test_02() {
        let res = [1, 2, 3, 4, 5].iter().wrap_iter(1, 2).map(|a|*a).collect::<Vec<i32>>();
        assert_eq!(&res, &[1, 2, 3, 4]);
    }

    #[test]
    fn test_03() {
        let res = [1, 2, 3, 4, 5].iter().wrap_iter(3, 2).map(|a|*a).collect::<Vec<i32>>();
        assert_eq!(&res, &[2, 3, 4, 5]);
    }
}



